home *** CD-ROM | disk | FTP | other *** search
/ Young Minds / Young Minds Interactive CD-ROM.ISO / umoria / misc1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-07-28  |  40.6 KB  |  1,814 lines
  1. #include <time.h>
  2. #include <math.h>
  3. #include <stdio.h>
  4. #include <sys/types.h>
  5.  
  6. #include "constants.h"
  7. #include "config.h"
  8. #include "types.h"
  9. /* SUN4 has a variable called class in the include file <math.h>
  10.    avoid a conflict by not defining my class in the file externs.h */
  11. #define DONT_DEFINE_CLASS
  12. #include "externs.h"
  13.  
  14. #ifdef USG
  15. #include <string.h>
  16. #else
  17. #include <strings.h>
  18. #endif
  19.  
  20. long time();
  21. struct tm *localtime();
  22. double sqrt();
  23. double cos();
  24. double fabs();
  25. #if defined(ultrix) || defined(sun) || defined(USG)
  26. int getuid();
  27. int geteuid();
  28. int getgid();
  29. int getegid();
  30. #else
  31. uid_t getuid();
  32. uid_t geteuid();
  33. uid_t getgid();
  34. uid_t getegid();
  35. #endif
  36.  
  37. #ifdef USG
  38. long lrand48();
  39. void srand48();
  40. unsigned short *seed48();
  41. #else
  42. long random();
  43. char *initstate();
  44. char *setstate();
  45. #endif
  46.  
  47. #ifdef ultrix
  48. void srandom();
  49. #endif
  50.  
  51. /* gets a new random seed for the random number generator */
  52. init_seeds()
  53. {
  54.   register long clock;
  55.   register int euid;
  56.  
  57.   /* in case game is setuid root */
  58.   if ((euid = geteuid()) == 0)
  59.     euid = (int)time((long *)0);
  60.  
  61.   clock = time((long *)0);
  62.   clock = clock * getpid() * euid;
  63. #ifdef USG
  64.   /* only uses randes_seed */
  65. #else
  66.   (void) initstate((unsigned int)clock, randes_state, STATE_SIZE);
  67. #endif
  68.   randes_seed = (unsigned int)clock;
  69.  
  70.   clock = time((long *)0);
  71.   clock = clock * getpid() * euid;
  72. #ifdef USG
  73.   /* only uses town_seed */
  74. #else
  75.   (void) initstate((unsigned int)clock, town_state, STATE_SIZE);
  76. #endif
  77.   town_seed = (unsigned int)clock;
  78.  
  79.   clock = time((long *)0);
  80. #if 0
  81.   clock = clock * getpid() * euid * getuid();
  82. #endif
  83. #ifdef USG
  84.   /* can't do this, so fake it */
  85.   srand48(clock);
  86.   /* make it a little more random */
  87.   for (clock = randint(100); clock >= 0; clock--)
  88.     (void) lrand48();
  89. #else
  90.   (void) initstate((unsigned int)clock, norm_state, STATE_SIZE);
  91.   /* make it a little more random */
  92.   for (clock = randint(100); clock >= 0; clock--)
  93.     (void) random();
  94. #endif
  95. }
  96.  
  97. #ifdef USG
  98. /* special array for restoring the SYS V number generator */
  99. unsigned short oldseed[3];
  100. #endif
  101.  
  102. /* change to different random number generator state */
  103. /*ARGSUSED*/
  104. set_seed(state, seed)
  105. char *state;
  106. int seed;
  107. {
  108. #ifdef USG
  109.   register unsigned short *pointer;
  110.  
  111.   /* make phony call to get pointer to old value of seed */
  112.   pointer = seed48(oldseed);
  113.   /* copy old seed into oldseed */
  114.   oldseed[0] = pointer[0];
  115.   oldseed[1] = pointer[1];
  116.   oldseed[2] = pointer[2];
  117.  
  118.   /* want reproducible state here, so call srand48 */
  119.   srand48((long)seed);
  120. #else
  121.   (void) setstate(state);
  122.   /* want reproducible state here, so call srandom */
  123.   srandom(seed);
  124. #endif
  125. }
  126.  
  127.  
  128. /* restore the normal random generator state */
  129. reset_seed()
  130. {
  131. #ifdef USG
  132.   (void) seed48(oldseed);
  133. #if 0
  134.   /* can't do this, so just call srand() with the current time */
  135.   srand48((unsigned int)(time ((long *)0)));
  136. #endif
  137. #else
  138.   (void) setstate(norm_state);
  139. #endif
  140. }
  141.  
  142.  
  143. /* Returns the day number; 0==Sunday...6==Saturday     -RAK-    */
  144. int day_num()
  145. {
  146.   long clock;
  147.   register struct tm *time_struct;
  148.  
  149.   clock = time((long *)0);
  150.   time_struct = localtime(&clock);
  151.   return (time_struct->tm_wday);
  152. }
  153.  
  154.  
  155. /* Returns the hour number; 0==midnight...23==11 PM    -RAK-    */
  156. int hour_num()
  157. {
  158.   long clock;
  159.   register struct tm *time_struct;
  160.  
  161.   clock = time((long *)0);
  162.   time_struct = localtime(&clock);
  163.   return (time_struct->tm_hour);
  164. }
  165.  
  166.  
  167. /* Check the day-time strings to see if open        -RAK-    */
  168. int check_time()
  169. {
  170.  switch ((int)days[day_num()][(hour_num()+4)]) {
  171.    case '.':  return(FALSE);    /* Closed                */
  172.    case 'X':  return(TRUE);     /* Normal hours          */
  173.    default:   return(FALSE);    /* Other, assumed closed */
  174.    }
  175. }
  176.  
  177.  
  178. /* Generates a random integer x where 1<==X<==MAXVAL    -RAK-    */
  179. int randint(maxval)
  180. int maxval;
  181. {
  182.   register long randval;
  183.  
  184. #ifdef USG
  185.   randval = lrand48();
  186. #else
  187.   randval = random();
  188. #endif
  189.   return ((randval % maxval) + 1);
  190. }
  191.  
  192. /* For i := 1 to y do sum := sum + randint(x) */
  193. int rand_rep(num, die)
  194. int num;
  195. int die;
  196. {
  197.   register int sum = 0;
  198.   register int i;
  199.  
  200.   for (i = 0; i < num; i++)
  201.     sum += randint(die);
  202.   return(sum);
  203. }
  204.  
  205. /* Generates a random integer number of NORMAL distribution -RAK-*/
  206. int randnor(mean, stand)
  207. int mean;
  208. int stand;
  209. {
  210.   return ((int)((sqrt(-2.0*log(randint((int)9999999)/10000000.0))*
  211.          cos(6.283*(randint((int)9999999)/10000000.0))*stand) + mean));
  212. }
  213.  
  214.  
  215. /* Returns position of first set bit            -RAK-    */
  216. /*     and clears that bit */
  217. int bit_pos(test)
  218. unsigned int *test;
  219. {
  220.   register int i;
  221.   register int mask = 0x1;
  222.  
  223.   for (i = 0; i < sizeof(int)*8; i++) {
  224.     if (*test & mask) {
  225.       *test &= ~mask;
  226.       return(i);
  227.     }
  228.     mask <<= 1;
  229.   }
  230.  
  231.   /* no one bits found */
  232.   return(-1);
  233. }
  234.  
  235. /* Checks a co-ordinate for in bounds status        -RAK-    */
  236. int in_bounds(y, x)
  237. int y, x;
  238. {
  239.   if ((y > 0) && (y < cur_height-1) && (x > 0) && (x < cur_width-1))
  240.     return(TRUE);
  241.   else
  242.     return(FALSE);
  243. }
  244.  
  245.  
  246. /* Distance between two points                -RAK-    */
  247. /* there is a bessel function names y1 in the math library, ignore warning */
  248. int distance(y1, x1, y2, x2)
  249. int y1, x1, y2, x2;
  250. {
  251.   register int dy, dx;
  252.  
  253.   dy = y1 - y2;
  254.   if (dy < 0)
  255.     dy = -dy;
  256.   dx = x1 - x2;
  257.   if (dx < 0)
  258.     dx = -dx;
  259.  
  260.   return( (2 * (dy + dx) - (dy > dx ? dx : dy)) / 2);
  261. }
  262.  
  263. /* Checks points north, south, east, and west for a type -RAK-    */
  264. int next_to4(y, x, elem_a, elem_b, elem_c)
  265. register int y, x;
  266. int elem_a, elem_b, elem_c;
  267. {
  268.   register int i;
  269.  
  270.   i = 0;
  271.   if (y > 0)
  272.     if ((cave[y-1][x].fval == elem_a) || (cave[y-1][x].fval == elem_b) ||
  273.     (cave[y-1][x].fval == elem_c))
  274.       i++;
  275.   if (y < cur_height-1)
  276.     if ((cave[y+1][x].fval == elem_a) || (cave[y+1][x].fval == elem_b) ||
  277.     (cave[y+1][x].fval == elem_c))
  278.       i++;
  279.   if (x > 0)
  280.     if ((cave[y][x-1].fval == elem_a) || (cave[y][x-1].fval == elem_b) ||
  281.     (cave[y][x-1].fval == elem_c))
  282.       i++;
  283.   if (x < cur_width-1)
  284.     if ((cave[y][x+1].fval == elem_a) || (cave[y][x+1].fval == elem_b) ||
  285.     (cave[y][x+1].fval == elem_c))
  286.       i++;
  287.   return(i);
  288. }
  289.  
  290.  
  291. /* Checks all adjacent spots for elements        -RAK-    */
  292. int next_to8(y, x, elem_a, elem_b, elem_c)
  293. register int y, x;
  294. int elem_a, elem_b, elem_c;
  295. {
  296.   register int k, j, i;
  297.  
  298.   i = 0;
  299.   for (j = (y - 1); j <= (y + 1); j++)
  300.     for (k = (x - 1); k <= (x + 1); k++)
  301.       if (in_bounds(j, k))
  302.     if ((cave[j][k].fval == elem_a) || (cave[j][k].fval == elem_b) ||
  303.         (cave[j][k].fval == elem_c))
  304.       i++;
  305.   return(i);
  306. }
  307.  
  308.  
  309. /* Link all free space in treasure list together         */
  310. tlink()
  311. {
  312.   register int i;
  313.  
  314.   for (i = 0; i < MAX_TALLOC; i++)
  315.     {
  316.       t_list[i] = blank_treasure;
  317.       t_list[i].p1 = i - 1;
  318.     }
  319.   tcptr = MAX_TALLOC - 1;
  320. }
  321.  
  322.  
  323. /* Link all free space in monster list together            */
  324. mlink()
  325. {
  326.   register int i;
  327.  
  328.   for (i = 0; i < MAX_MALLOC; i++)
  329.     {
  330.       m_list[i] = blank_monster;
  331.       m_list[i].nptr = i - 1;
  332.     }
  333.   m_list[1].nptr = 0;
  334.   muptr = 0;
  335.   mfptr = MAX_MALLOC - 1;
  336. }
  337.  
  338.  
  339. /* Initializes M_LEVEL array for use with PLACE_MONSTER    -RAK-    */
  340. init_m_level()
  341. {
  342.   register int i, j, k;
  343.  
  344.   i = 0;
  345.   j = 0;
  346.   k = MAX_CREATURES - WIN_MON_TOT;
  347.   while (j <= MAX_MONS_LEVEL) {
  348.     m_level[j] = 0;
  349.     while ((i < k) && (c_list[i].level == j))
  350.       {
  351.     m_level[j]++;
  352.     i++;
  353.       }
  354.     j++;
  355.   }
  356.   for (i = 2; i <= MAX_MONS_LEVEL; i++)
  357.     m_level[i] += m_level[i-1];
  358. }
  359.  
  360.  
  361. /* Initializes T_LEVEL array for use with PLACE_OBJECT    -RAK-    */
  362. init_t_level()
  363. {
  364.   register int i, j;
  365.  
  366.   i = 0;
  367.   j = 0;
  368.   while ((j <= MAX_OBJ_LEVEL) && (i < MAX_OBJECTS))
  369.     {
  370.       while ((i < MAX_OBJECTS) && (object_list[i].level == j))
  371.     {
  372.       t_level[j]++;
  373.       i++;
  374.     }
  375.       j++;
  376.     }
  377.   for (i = 1; i <= MAX_OBJ_LEVEL; i++)
  378.     t_level[i] += t_level[i-1];
  379. }
  380.  
  381.  
  382. /* Adjust prices of objects                -RAK-    */
  383. price_adjust()
  384. {
  385.   register int i;
  386.  
  387.   for (i = 0; i < MAX_OBJECTS; i++)
  388.     object_list[i].cost = object_list[i].cost*COST_ADJ + 0.99;
  389.   for (i = 0; i < INVEN_INIT_MAX; i++)
  390.     inventory_init[i].cost = inventory_init[i].cost*COST_ADJ + 0.99;
  391. }
  392.  
  393.  
  394. /* Converts input string into a dice roll        -RAK-    */
  395. /*       Normal input string will look like "2d6", "3d8"... etc. */
  396. int damroll(dice)
  397. char *dice;
  398. {
  399.   int num, sides;
  400.  
  401.   num = 0;
  402.   sides = 0;
  403.   (void) sscanf(dice, "%d d %d", &num, &sides);
  404.   return(rand_rep(num, sides));
  405. }
  406.  
  407.  
  408. /* Returns true if no obstructions between two given points -RAK-*/
  409. /* there is a bessel function names y1 in the math library, ignore warning */
  410. int los(y1, x1, y2, x2)
  411. int y1, x1, y2, x2;
  412. {
  413.   register int ty, tx, stepy, stepx;
  414.   int aty, atx, p1, p2;
  415.   double slp, tmp;
  416.   int flag;
  417.  
  418.   ty = (y1 - y2);
  419.   tx = (x1 - x2);
  420.   flag = TRUE;
  421.   if ((ty != 0) || (tx != 0))
  422.     {
  423.       if (ty < 0)
  424.     {
  425.       stepy = -1;
  426.       aty = -ty;
  427.     }
  428.       else
  429.     {
  430.       stepy = 1;
  431.       aty = ty;
  432.     }
  433.       if (tx < 0)
  434.     {
  435.       stepx = -1;
  436.       atx = -tx;
  437.     }
  438.       else
  439.     {
  440.       stepx = 1;
  441.       atx = tx;
  442.     }
  443.       if (ty == 0)
  444.     {
  445.       do
  446.         {
  447.           x2 += stepx;
  448.           flag = cave[y2][x2].fopen;
  449.         }
  450.       while((x1 != x2) && (flag));
  451.     }
  452.       else if (tx == 0)
  453.     {
  454.       do
  455.         {
  456.           y2 += stepy;
  457.           flag = cave[y2][x2].fopen;
  458.         }
  459.       while((y1 != y2) && (flag));
  460.     }
  461.       else if (aty > atx)
  462.     {
  463.       slp = ((double)atx / (double)aty) * stepx;
  464.       tmp = x2;
  465.       do
  466.         {
  467.           y2 += stepy;
  468.           tmp += slp;
  469.               /* round to nearest integer */
  470.           p1 = (int)floor(tmp - 0.1 + 0.5);
  471.           p2 = (int)floor(tmp + 0.1 + 0.5);
  472.           if ((!cave[y2][p1].fopen) && (!cave[y2][p2].fopen))
  473.           flag = FALSE;
  474.         }
  475.       while((y1 != y2) && (flag));
  476.     }
  477.       else
  478.     {
  479.       slp = ((double)aty / (double)atx) * stepy;
  480.       tmp = y2;
  481.       do
  482.         {
  483.           x2 += stepx;
  484.           tmp += slp;
  485.               /* round to nearest integer */
  486.           p1 = (int)floor(tmp - 0.1 + 0.5);
  487.           p2 = (int)floor(tmp + 0.1 + 0.5);
  488.           if ((!cave[p1][x2].fopen) && (!cave[p2][x2].fopen))
  489.         flag = FALSE;
  490.         }
  491.       while((x1 != x2) && (flag));
  492.     }
  493.     }
  494.   return(flag);
  495. }
  496.  
  497.  
  498. /* Returns symbol for given row, column            -RAK-    */
  499. loc_symbol(y, x, sym)
  500. int y, x;
  501. char *sym;
  502. {
  503.   register cave_type *cave_ptr;
  504.   register monster_type *mon_ptr;
  505.  
  506.   cave_ptr = &cave[y][x];
  507.   if ((cave_ptr->cptr == 1) && (!find_flag))
  508.     *sym = '@';
  509.   else if (py.flags.blind > 0)
  510.     *sym = ' ';
  511.   else
  512.     {
  513.       if (cave_ptr->cptr > 1)
  514.     {
  515.       mon_ptr = &m_list[cave_ptr->cptr];
  516.       if ((mon_ptr->ml) &&
  517.           (((c_list[mon_ptr->mptr].cmove & 0x00010000) == 0) ||
  518.            (py.flags.see_inv)))
  519.         *sym = c_list[mon_ptr->mptr].cchar;
  520.       else if (cave_ptr->tptr != 0)
  521.         *sym = t_list[cave_ptr->tptr].tchar;
  522.       else if (cave_ptr->fval < 10)
  523.         *sym = '.';
  524.       else
  525.         *sym = '#';
  526.     }
  527.       else if (cave_ptr->tptr != 0)
  528.     *sym = t_list[cave_ptr->tptr].tchar;
  529.       else if (cave_ptr->fval < 10)
  530.     *sym = '.';
  531.       else
  532.     *sym = '#';
  533.     }
  534. }
  535.  
  536.  
  537. /* Tests a spot for light or field mark status        -RAK-    */
  538. int test_light(y, x)
  539. int y, x;
  540. {
  541.   register cave_type *cave_ptr;
  542.  
  543.   cave_ptr = &cave[y][x];
  544.   if ((cave_ptr->pl) || (cave_ptr->fm) || (cave_ptr->tl))
  545.     return(TRUE);
  546.   else
  547.     return(FALSE);
  548. }
  549.  
  550.  
  551. /* Prints the map of the dungeon             -RAK-    */
  552. prt_map()
  553. {
  554.   register int i, j, k;
  555.   int l, m;
  556.   int ypos, isp;
  557.   /* this eliminates lint warning: xpos may be used before set */
  558.   int xpos = 0;
  559.   vtype floor_str;
  560.   char tmp_char[2];
  561.   int flag;
  562.   register cave_type *cave_ptr;
  563.  
  564.   k = 0;                          /* Used for erasing dirty lines  */
  565.   l = 13;                         /* Erasure starts in this column */
  566.   for (i = panel_row_min; i <= panel_row_max; i++)  /* Top to bottom */
  567.     {
  568.       k++;                     /* Increment dirty line ctr      */
  569.       if (used_line[k])        /* If line is dirty...           */
  570.     {
  571.       erase_line(k, l);        /* erase it.                    */
  572.       used_line[k] = FALSE;   /* Now it's a clean line         */
  573.     }
  574.       floor_str[0] = '\0';              /* Floor_str is string to be printed*/
  575.       ypos = i;                   /* Save row                      */
  576.       flag = FALSE;                /* False until floor_str != ""   */
  577.       isp = 0;                     /* Number of blanks encountered  */
  578.       for (j = panel_col_min; j <= panel_col_max; j++)  /* Left to right */
  579.     {
  580.       cave_ptr = &cave[i][j];    /* Get character for location    */
  581.       if (cave_ptr->pl || cave_ptr->fm || cave_ptr->tl)
  582.         loc_symbol(i, j, tmp_char);
  583.       else if ((cave_ptr->cptr == 1) && (!find_flag))
  584.         tmp_char[0] = '@';
  585.       else if (cave_ptr->cptr > 1)
  586.         if (m_list[cave_ptr->cptr].ml)
  587.           loc_symbol(i, j, tmp_char);
  588.         else
  589.           tmp_char[0] = ' ';
  590.       else
  591.         tmp_char[0] = ' ';
  592.       if (py.flags.image > 0)
  593.         if (randint(12) == 1)
  594.           tmp_char[0] = (randint(95) + 31);
  595.       if (tmp_char[0] == ' ') /* If blank...                   */
  596.         {
  597.           if (flag)       /* If floor_str != ""        */
  598.         {
  599.           isp++;      /* Increment blank ctr           */
  600.           if (isp > 3)        /* Too many blanks, print*/
  601.             {                 /* floor_str and reset   */
  602.               print(floor_str, ypos, xpos);
  603.               flag = FALSE;
  604.               isp = 0;
  605.             }
  606.         }
  607.         }
  608.       else
  609.         {
  610.           if (flag)       /* Floor_str != ""               */
  611.         {
  612.           if (isp > 0)        /* Add on the blanks     */
  613.             {
  614.               for (m = 0; m < isp; m++)
  615.             (void) strcat(floor_str, " ");
  616.               isp = 0;
  617.             }                  /* Add on the character  */
  618.           tmp_char[1] = '\0';
  619.           (void) strcat(floor_str, tmp_char);
  620.         }
  621.           else
  622.         {             /* Floor_str == ""                */
  623.           xpos = j;     /* Save column for printing      */
  624.           flag = TRUE;   /* Set flag to true              */
  625.           floor_str[0] = tmp_char[0];  /* Floor_str != ""       */
  626.           floor_str[1] = '\0';
  627.         }
  628.         }
  629.     }
  630.       if (flag)                 /* Print remainder, if any       */
  631.     print(floor_str, ypos, xpos);
  632.     }
  633. }
  634.  
  635.  
  636. /* Compact monsters                    -RAK-    */
  637. compact_monsters()
  638. {
  639.   register int i, j, k;
  640.   int cur_dis;
  641.   int delete_1, delete_any;
  642.   register monster_type *mon_ptr;
  643.  
  644.   cur_dis = 66;
  645.   delete_any = FALSE;
  646.   do
  647.     {
  648.       i = muptr;
  649.       j = 0;
  650.       while (i > 0)
  651.     {
  652.       delete_1 = FALSE;
  653.       k = m_list[i].nptr;
  654.       mon_ptr = &m_list[i];
  655.       if (cur_dis > mon_ptr->cdis)
  656.         if (randint(3) == 1)
  657.           {
  658.         if (j == 0)
  659.           muptr = k;
  660.         else
  661.           m_list[j].nptr = k;
  662.         cave[mon_ptr->fy][mon_ptr->fx].cptr = 0;
  663.         m_list[i] = blank_monster;
  664.         m_list[i].nptr = mfptr;
  665.         mfptr = i;
  666.         delete_1 = TRUE;
  667.         delete_any = TRUE;
  668.           }
  669.       if (!delete_1)
  670.         j = i;
  671.       i = k;
  672.     }
  673.       if (!delete_any)
  674.     cur_dis -= 6;
  675.     }
  676.   while (!delete_any);
  677.   if (cur_dis < 66)
  678.     prt_map();
  679. }
  680.  
  681.  
  682. /* Returns a pointer to next free space            -RAK-    */
  683. popm(x)
  684. register int *x;
  685. {
  686.   if (mfptr <= 1)
  687.     compact_monsters();
  688.   *x = mfptr;
  689.   mfptr = m_list[*x].nptr;
  690. }
  691.  
  692.  
  693. /* Pushs a record back onto free space list        -RAK-    */
  694. pushm(x)
  695. register int x;
  696. {
  697.   m_list[x] = blank_monster;
  698.   m_list[x].nptr = mfptr;
  699.   mfptr = x;
  700. }
  701.  
  702.  
  703. /* Gives Max hit points                    -RAK-    */
  704. int max_hp(hp_str)
  705. char *hp_str;
  706. {
  707.   int num, die;
  708.  
  709.   (void) sscanf(hp_str, "%d d %d", &num, &die);
  710.   return(num*die);
  711. }
  712.  
  713.  
  714. /* Places a monster at given location            -RAK-    */
  715. place_monster(y, x, z, slp)
  716. register int y, x, z;
  717. int slp;
  718. {
  719.   int cur_pos;
  720.   register monster_type *mon_ptr;
  721.  
  722.   popm(&cur_pos);
  723.   mon_ptr = &m_list[cur_pos];
  724.   mon_ptr->fy = y;
  725.   mon_ptr->fx = x;
  726.   mon_ptr->mptr = z;
  727.   mon_ptr->nptr = muptr;
  728.   muptr = cur_pos;
  729.   if (c_list[z].cdefense & 0x4000)
  730.     mon_ptr->hp = max_hp(c_list[z].hd);
  731.   else
  732.     mon_ptr->hp = damroll(c_list[z].hd);
  733.   mon_ptr->cspeed = c_list[z].speed + py.flags.speed;
  734.   mon_ptr->stunned = 0;
  735.   mon_ptr->cdis = distance(char_row, char_col,y,x);
  736.   cave[y][x].cptr = cur_pos;
  737.   if (slp)
  738.     {
  739.       if (c_list[z].sleep == 0)
  740.     mon_ptr->csleep = 0;
  741.       else
  742.     mon_ptr->csleep = (c_list[z].sleep/5.0) + randint(c_list[z].sleep);
  743.     }
  744.   else
  745.     mon_ptr->csleep = 0;
  746. }
  747.  
  748.  
  749. /* Places a monster at given location            -RAK-    */
  750. place_win_monster()
  751. {
  752.   int cur_pos;
  753.   register int y, x;
  754.   register monster_type *mon_ptr;
  755.  
  756.   if (!total_winner)
  757.     {
  758.       popm(&cur_pos);
  759.       mon_ptr = &m_list[cur_pos];
  760.       do
  761.     {
  762.       y = randint(cur_height-2);
  763.       x = randint(cur_width-2);
  764.     }
  765.       while (((cave[y][x].fval != 1) && (cave[y][x].fval != 2) &&
  766.         (cave[y][x].fval != 4)) ||
  767.          (cave[y][x].cptr != 0) ||
  768.          (cave[y][x].tptr != 0) ||
  769.          (distance(y,x,char_row, char_col) <= MAX_SIGHT));
  770.       mon_ptr->fy = y;
  771.       mon_ptr->fx = x;
  772.       mon_ptr->mptr = randint(WIN_MON_TOT) - 1 + m_level[MAX_MONS_LEVEL] +
  773.     m_level[0];
  774.       mon_ptr->nptr = muptr;
  775.       muptr = cur_pos;
  776.       if (c_list[mon_ptr->mptr].cdefense & 0x4000)
  777.     mon_ptr->hp = max_hp(c_list[mon_ptr->mptr].hd);
  778.       else
  779.     mon_ptr->hp = damroll(c_list[mon_ptr->mptr].hd);
  780.       mon_ptr->cspeed = c_list[mon_ptr->mptr].speed + py.flags.speed;
  781.       mon_ptr->stunned = 0;
  782.       mon_ptr->cdis = distance(char_row, char_col,y,x);
  783.       cave[y][x].cptr = cur_pos;
  784.       mon_ptr->csleep = 0;
  785.     }
  786. }
  787.  
  788. /* Allocates a random monster                -RAK-    */
  789. alloc_monster(alloc_set, num, dis, slp)
  790. int (*alloc_set)();
  791. int num, dis;
  792. int slp;
  793. {
  794.   register int y, x, i, j, k;
  795.  
  796.   for (i = 0; i < num; i++)
  797.     {
  798.       do
  799.     {
  800.       y = randint(cur_height-2);
  801.       x = randint(cur_width-2);
  802.     }
  803.       while ((!(*alloc_set)(cave[y][x].fval)) ||
  804.          (cave[y][x].cptr != 0) ||
  805.          (!cave[y][x].fopen) ||
  806.          (distance(y,x,char_row, char_col) <= dis));
  807.       if (dun_level == 0)
  808.     j = randint(m_level[0]) - 1;
  809.       else if (dun_level >= MAX_MONS_LEVEL)
  810.     j = randint(m_level[MAX_MONS_LEVEL]) - 1 + m_level[0];
  811.       else if (randint(MON_NASTY) == 1)
  812.     {
  813.       /* abs may be a macro, don't call it with randnor as a parameter */
  814.       k = randnor(0, 4);
  815.       j = dun_level + abs(k) + 1;
  816.       if (j > MAX_MONS_LEVEL)
  817.         j = MAX_MONS_LEVEL;
  818.       k = m_level[j] - m_level[j-1];
  819.       j = randint(k) - 1 + m_level[j-1];
  820.     }
  821.       else
  822.     j = randint(m_level[dun_level]) - 1 + m_level[0];
  823.       place_monster(y, x, j, slp);
  824.     }
  825. }
  826.  
  827.  
  828. /* Places creature adjacent to given location        -RAK-    */
  829. int summon_monster(y, x, slp)
  830. int *y, *x;
  831. int slp;
  832. {
  833.   register int i, j, k;
  834.   int l, m;
  835.   register cave_type *cave_ptr;
  836.   int summon;
  837.  
  838.   i = 0;
  839.   m = dun_level + MON_SUMMON_ADJ;
  840.   summon = FALSE;
  841.   if (m > MAX_MONS_LEVEL)
  842.     l = MAX_MONS_LEVEL;
  843.   else
  844.     l = m;
  845.   if (dun_level == 0)
  846.     l = randint(m_level[0]) - 1;
  847.   else
  848.     l = randint(m_level[l]) - 1 + m_level[0];
  849.   do
  850.     {
  851.       j = *y - 2 + randint(3);
  852.       k = *x - 2 + randint(3);
  853.       if (in_bounds(j, k))
  854.     {
  855.       cave_ptr = &cave[j][k];
  856.       if ((cave_ptr->fval == 1) || (cave_ptr->fval == 2) ||
  857.           (cave_ptr->fval == 4) || (cave_ptr->fval == 5))
  858.         if (cave_ptr->cptr == 0)
  859.           if (cave_ptr->fopen)
  860.         {
  861.           place_monster(j, k, l, slp);
  862.           summon = TRUE;
  863.           i = 9;
  864.           *y = j;
  865.           *x = k;
  866.         }
  867.     }
  868.       i++;
  869.     }
  870.   while (i <= 9);
  871.   return(summon);
  872. }
  873.  
  874.  
  875. /* Places undead adjacent to given location        -RAK-    */
  876. int summon_undead(y, x)
  877. int *y, *x;
  878. {
  879.   register int i, j, k;
  880.   int l, m, ctr;
  881.   int summon;
  882.   register cave_type *cave_ptr;
  883.  
  884.   i = 0;
  885.   summon = FALSE;
  886.   l = m_level[MAX_MONS_LEVEL] + m_level[0];
  887.   do
  888.     {
  889.       m = randint(l) - 1;
  890.       ctr = 0;
  891.       do
  892.     {
  893.       if (c_list[m].cdefense & 0x0008)
  894.         {
  895.           ctr = 20;
  896.           l  = 0;
  897.         }
  898.       else
  899.         {
  900.           m++;
  901.           if (m > l)
  902.         ctr = 20;
  903.           else
  904.         ctr++;
  905.         }
  906.     }
  907.       while (ctr <= 19);
  908.     }
  909.   while(l != 0);
  910.   do
  911.     {
  912.       j = *y - 2 + randint(3);
  913.       k = *x - 2 + randint(3);
  914.       if (in_bounds(j, k))
  915.     {
  916.       cave_ptr = &cave[j][k];
  917.       if ((cave_ptr->fval == 1) || (cave_ptr->fval == 2) ||
  918.           (cave_ptr->fval == 4) || (cave_ptr->fval == 5))
  919.         if ((cave_ptr->cptr == 0) && (cave_ptr->fopen))
  920.           {
  921.         place_monster(j, k, m, FALSE);
  922.         summon = TRUE;
  923.         i = 9;
  924.         *y = j;
  925.         *x = k;
  926.           }
  927.     }
  928.       i++;
  929.     }
  930.   while(i <= 9);
  931.   return(summon);
  932. }
  933.  
  934.  
  935. /* If too many objects on floor level, delete some of them-RAK-    */
  936. compact_objects()
  937. {
  938.   register int i, j;
  939.   int ctr, cur_dis;
  940.   int flag;
  941.   register cave_type *cave_ptr;
  942.   register treasure_type *t_ptr;
  943.  
  944.   ctr = 0;
  945.   cur_dis = 66;
  946.   do
  947.     {
  948.       for (i = 0; i < cur_height; i++)
  949.     for (j = 0; j < cur_width; j++)
  950.       {
  951.         cave_ptr = &cave[i][j];
  952.         if (cave_ptr->tptr != 0)
  953.           if (distance(i, j, char_row, char_col) > cur_dis)
  954.         {
  955.           flag = FALSE;
  956.           t_ptr = &t_list[cave_ptr->tptr];
  957.           switch(t_ptr->tval)
  958.             {
  959.             case 102:
  960.               if ((t_ptr->subval == 1) || (t_ptr->subval == 6) ||
  961.               (t_ptr->subval == 9))
  962.             flag = TRUE;
  963.               else if (randint(4) == 1)
  964.             flag = TRUE;
  965.               break;
  966.             case 103:
  967.               flag = TRUE;
  968.               break;
  969.             case 104: case 105:
  970.               /* doors */
  971.               if (randint(4) == 1)  flag = TRUE;
  972.               break;
  973.             case 107: case 108:
  974.               /* stairs, don't delete them */
  975.               break;
  976.             case 110:
  977.               /* shop doors, don't delete them */
  978.               break;
  979.             default:
  980.               if (randint(8) == 1)  flag = TRUE;
  981.             }
  982.           if (flag)
  983.             {
  984.               cave_ptr->fopen = TRUE;
  985.               t_list[cave_ptr->tptr] = blank_treasure;
  986.               t_list[cave_ptr->tptr].p1 = tcptr;
  987.               tcptr = cave_ptr->tptr;
  988.               cave_ptr->tptr = 0;
  989.               ctr++;
  990.             }
  991.         }
  992.         if (ctr == 0)  cur_dis -= 6;
  993.       }
  994.     }
  995.   while (ctr <= 0);
  996.   if (cur_dis < 66)  prt_map();
  997. }
  998.  
  999.  
  1000.  
  1001. /* Gives pointer to next free space            -RAK-    */
  1002. popt(x)
  1003. int *x;
  1004. {
  1005.   if (tcptr < 1)
  1006.     compact_objects();
  1007.   *x = tcptr;
  1008.   tcptr = t_list[*x].p1;
  1009. }
  1010.  
  1011.  
  1012. /* Pushs a record back onto free space list        -RAK-    */
  1013. pusht(x)
  1014. register int x;
  1015. {
  1016.   t_list[x] = blank_treasure;
  1017.   t_list[x].p1 = tcptr;
  1018.   tcptr = x;
  1019. }
  1020.  
  1021.  
  1022. /* Order the treasure list by level            -RAK-    */
  1023. sort_objects()
  1024. {
  1025.   register int i, j, k, gap;
  1026.   treasure_type tmp;
  1027.  
  1028.   gap = MAX_OBJECTS / 2;
  1029.   while (gap > 0)
  1030.     {
  1031.       for (i = gap; i < MAX_OBJECTS; i++)
  1032.     {
  1033.       j = i - gap;
  1034.       while (j >= 0)
  1035.         {
  1036.           k = j + gap;
  1037.           if (object_list[j].level > object_list[k].level)
  1038.         {
  1039.           tmp = object_list[j];
  1040.           object_list[j] = object_list[k];
  1041.           object_list[k] = tmp;
  1042.         }
  1043.           else
  1044.         j = -1;
  1045.           j -= gap;
  1046.         }
  1047.     }
  1048.       gap = gap / 2;
  1049.     }
  1050. }
  1051.  
  1052.  
  1053. /* Boolean : is object enchanted       -RAK- */
  1054. int magik(chance)
  1055. int chance;
  1056. {
  1057.   if (randint(100) <= chance)
  1058.     return(TRUE);
  1059.   else
  1060.     return(FALSE);
  1061. }
  1062.  
  1063.  
  1064. /* Enchant a bonus based on degree desired -RAK- */
  1065. int m_bonus(base, max_std, level)
  1066. int base, max_std, level;
  1067. {
  1068.   register int x, stand_dev;
  1069.   register int tmp;
  1070.  
  1071.   stand_dev = (OBJ_STD_ADJ*level) + OBJ_STD_MIN;
  1072.   if (stand_dev > max_std)
  1073.     stand_dev = max_std;
  1074.   /* abs may be a macro, don't call it with randnor as a parameter */
  1075.   tmp = randnor(0, stand_dev);
  1076.   x = (abs(tmp)/10.0) + base;
  1077.   if (x < base)
  1078.     return(base);
  1079.   else
  1080.     return(x);
  1081. }
  1082.  
  1083.  
  1084. /* Chance of treasure having magic abilities        -RAK-    */
  1085. /* Chance increases with each dungeon level                      */
  1086. magic_treasure(x, level)
  1087. int x, level;
  1088. {
  1089.   register treasure_type *t_ptr;
  1090.   register int chance, special, cursed, i;
  1091.  
  1092.   chance = OBJ_BASE_MAGIC + level;
  1093.   if (chance > OBJ_BASE_MAX)
  1094.     chance = OBJ_BASE_MAX;
  1095.   special = (chance/OBJ_DIV_SPECIAL);
  1096.   cursed  = (chance/OBJ_DIV_CURSED);
  1097.   t_ptr = &t_list[x];
  1098. /*  I vehemently disagree with this!! */
  1099. /*  t_ptr->level = level;  */
  1100.   /* Depending on treasure type, it can have certain magical properties*/
  1101.   switch (t_ptr->tval)
  1102.     {
  1103.     case 34: case 35: case 36:  /* Armor and shields*/
  1104.       if (magik(chance))
  1105.     {
  1106.       t_ptr->toac = m_bonus(1, 30, level);
  1107.       if (magik(special))
  1108.         switch(randint(9))
  1109.           {
  1110.           case 1:
  1111.         t_ptr->flags |= 0x02380000;
  1112.         (void) strcat(t_ptr->name, " (R)");
  1113.         t_ptr->toac += 5;
  1114.         t_ptr->cost += 2500;
  1115.         break;
  1116.           case 2:    /* Resist Acid   */
  1117.         t_ptr->flags |= 0x00100000;
  1118.         (void) strcat(t_ptr->name, " (RA)");
  1119.         t_ptr->cost += 1000;
  1120.         break;
  1121.           case 3: case 4:    /* Resist Fire   */
  1122.         t_ptr->flags |= 0x00080000;
  1123.         (void) strcat(t_ptr->name, " (RF)");
  1124.         t_ptr->cost += 600;
  1125.         break;
  1126.           case 5: case 6:   /* Resist Cold   */
  1127.         t_ptr->flags |= 0x00200000;
  1128.         (void) strcat(t_ptr->name, " (RC)");
  1129.         t_ptr->cost += 600;
  1130.         break;
  1131.           case 7: case 8: case 9:  /* Resist Lightning*/
  1132.         t_ptr->flags |= 0x02000000;
  1133.         (void) strcat(t_ptr->name, " (RL)");
  1134.         t_ptr->cost += 500;
  1135.         break;
  1136.           }
  1137.     }
  1138.       else if (magik(cursed))
  1139.     {
  1140.       t_ptr->toac = -m_bonus(1, 40, level);
  1141.       t_ptr->cost = 0;
  1142.       t_ptr->flags |= 0x80000000;
  1143.     }
  1144.       break;
  1145.  
  1146.     case 21: case 22: case 23:  /* Weapons       */
  1147.       if (magik(chance))
  1148.     {
  1149.       t_ptr->tohit = m_bonus(0, 40, level);
  1150.       t_ptr->todam = m_bonus(0, 40, level);
  1151.       if (magik(special))
  1152.         switch(randint(16))
  1153.           {
  1154.         case 1:   /* Holy Avenger  */
  1155.         t_ptr->flags |= 0x01418001;
  1156.         t_ptr->tohit += 5;
  1157.         t_ptr->todam += 5;
  1158.         t_ptr->toac  = randint(4);
  1159.         /* the value in p1 is used for strength increase */
  1160.         t_ptr->p1    = randint(4);
  1161.         (void) strcat(t_ptr->name, " [%P4] (HA) (%P1 to STR)");
  1162.         t_ptr->cost += t_ptr->p1*500;
  1163.         t_ptr->cost += 10000;
  1164.         break;
  1165.           case 2:   /* Defender      */
  1166.         t_ptr->flags |= 0x07B80900;
  1167.         t_ptr->tohit += 3;
  1168.         t_ptr->todam += 3;
  1169.         t_ptr->toac  = 5 + randint(5);
  1170.         (void) strcat(t_ptr->name, " [%P4] (DF)");
  1171.         /* note that the value in p1 is unused */
  1172.         t_ptr->p1    = randint(3);
  1173.         t_ptr->cost += t_ptr->p1*500;
  1174.         t_ptr->cost += 7500;
  1175.         break;
  1176.           case 3: case 4:    /* Slay Monster  */
  1177.         t_ptr->flags |= 0x01004000;
  1178.         t_ptr->tohit += 3;
  1179.         t_ptr->todam += 3;
  1180.         (void) strcat(t_ptr->name, " (SM)");
  1181.         t_ptr->cost += 5000;
  1182.         break;
  1183.           case 5: case 6:   /* Slay Dragon   */
  1184.         t_ptr->flags |= 0x00002000;
  1185.         t_ptr->tohit += 3;
  1186.         t_ptr->todam += 3;
  1187.         (void) strcat(t_ptr->name, " (SD)");
  1188.         t_ptr->cost += 4000;
  1189.         break;
  1190.           case 7: case 8:     /* Slay Evil     */
  1191.         t_ptr->flags |= 0x00008000;
  1192.         t_ptr->tohit += 3;
  1193.         t_ptr->todam += 3;
  1194.         (void) strcat(t_ptr->name, " (SE)");
  1195.         t_ptr->cost += 4000;
  1196.         break;
  1197.           case 9: case 10:   /* Slay Undead   */
  1198.         t_ptr->flags |= 0x00010000;
  1199.         t_ptr->tohit += 2;
  1200.         t_ptr->todam += 2;
  1201.         (void) strcat(t_ptr->name, " (SU)");
  1202.         t_ptr->cost += 3000;
  1203.         break;
  1204.           case 11: case 12: case 13:   /* Flame Tongue  */
  1205.         t_ptr->flags |= 0x00040000;
  1206.         t_ptr->tohit++;
  1207.         t_ptr->todam += 3;
  1208.         (void) strcat(t_ptr->name, " (FT)");
  1209.         t_ptr->cost += 2000;
  1210.         break;
  1211.           case 14: case 15: case 16:   /* Frost Brand   */
  1212.         t_ptr->flags |= 0x00020000;
  1213.         t_ptr->tohit++;
  1214.         t_ptr->todam++;
  1215.         (void) strcat(t_ptr->name, " (FB)");
  1216.         t_ptr->cost += 1200;
  1217.         break;
  1218.           }
  1219.     }
  1220.       else if (magik(cursed))
  1221.     {
  1222.       t_ptr->tohit = -m_bonus(1, 55, level);
  1223.       t_ptr->todam = -m_bonus(1, 55, level);
  1224.       t_ptr->flags |= 0x80000000;
  1225.       t_ptr->cost = 0;
  1226.     }
  1227.       break;
  1228.  
  1229.     case 20:  /* Bows, crossbows, and slings   */
  1230.       if (magik(chance))
  1231.     t_ptr->tohit = m_bonus(1, 30, level);
  1232.       else if (magik(cursed))
  1233.     {
  1234.       t_ptr->tohit = -m_bonus(1, 50, level);
  1235.       t_ptr->flags |= 0x80000000;
  1236.       t_ptr->cost = 0;
  1237.     }
  1238.       break;
  1239.  
  1240.     case 25:  /* Digging tools         */
  1241.       if (magik(chance))
  1242.     switch(randint(3))
  1243.       {
  1244.       case 1: case 2:
  1245.         t_ptr->p1 = m_bonus(2, 25, level);
  1246.         t_ptr->cost += t_ptr->p1*100;
  1247.         break;
  1248.       case 3:
  1249.         t_ptr->p1 = -m_bonus(1, 30, level);
  1250.         t_ptr->cost = 0;
  1251.         t_ptr->flags |= 0x80000000;
  1252.       }
  1253.       break;
  1254.  
  1255.     case 31:  /* Gloves and Gauntlets  */
  1256.       if (magik(chance))
  1257.     {
  1258.       t_ptr->toac = m_bonus(1, 20, level);
  1259.       if (magik(special))
  1260.         switch(randint(2))
  1261.           {
  1262.           case 1:
  1263.         t_ptr->flags |= 0x00800000;
  1264.         (void) strcat(t_ptr->name, " of Free Action");
  1265.         t_ptr->cost += 1000;
  1266.         break;
  1267.           case 2:
  1268.         t_ptr->tohit = 1 + randint(3);
  1269.         t_ptr->todam = 1 + randint(3);
  1270.         (void) strcat(t_ptr->name, " of Slaying (%P2,%P3)");
  1271.         t_ptr->cost += (t_ptr->tohit+t_ptr->todam)*250;
  1272.         break;
  1273.           }
  1274.     }
  1275.       else if (magik(cursed))
  1276.     {
  1277.       if (magik(special))
  1278.         switch(randint(2))
  1279.           {
  1280.           case 1:
  1281.         t_ptr->flags |= 0x80000002;
  1282.         (void) strcat(t_ptr->name, " of Clumsiness");
  1283.         t_ptr->p1 = 1;
  1284.         break;
  1285.           case 2:
  1286.         t_ptr->flags |= 0x80000001;
  1287.         (void) strcat(t_ptr->name, " of Weakness");
  1288.         t_ptr->p1 = 1;
  1289.         break;
  1290.           }
  1291.       t_ptr->toac = -m_bonus(1, 40, level);
  1292.       t_ptr->p1   = -m_bonus(1, 10, level);
  1293.       t_ptr->flags |= 0x80000000;
  1294.       t_ptr->cost = 0;
  1295.     }
  1296.       break;
  1297.  
  1298.     case 30:  /* Boots */
  1299.       if (magik(chance))
  1300.     {
  1301.       t_ptr->toac = m_bonus(1, 20, level);
  1302.       if (magik(special))
  1303.         switch(randint(12))
  1304.           {
  1305.           case 1:
  1306.         t_ptr->flags |= 0x00001000;
  1307.         (void) strcat(t_ptr->name, " of Speed");
  1308.         t_ptr->p1 = 1;
  1309.         t_ptr->cost += 5000;
  1310.         break;
  1311.           case 2: case 3: case 4: case 5:
  1312.         t_ptr->flags |= 0x00000100;
  1313.         t_ptr->p1 = randint(3);
  1314.         (void) strcat(t_ptr->name, " of Stealth (%P1)");
  1315.         t_ptr->cost += 500;
  1316.         break;
  1317.           default:
  1318.         t_ptr->flags |= 0x04000000;
  1319.         (void) strcat(t_ptr->name, " of Slow descent");
  1320.         t_ptr->cost += 250;
  1321.         break;
  1322.           }
  1323.     }
  1324.       else if (magik(cursed))
  1325.     {
  1326.     switch(randint(3))
  1327.       {
  1328.         case 1:
  1329.         t_ptr->flags |= 0x80001000;
  1330.         (void) strcat(t_ptr->name, " of Slowness");
  1331.         t_ptr->p1 = -1;
  1332.         break;
  1333.       case 2:
  1334.         t_ptr->flags |= 0x80000200;
  1335.         (void) strcat(t_ptr->name, " of Noise");
  1336.         break;
  1337.       case 3:
  1338.         t_ptr->flags |= 0x80000000;
  1339.         (void) strcat(t_ptr->name, " of Great Mass");
  1340.         t_ptr->weight = t_ptr->weight * 5;
  1341.         break;
  1342.       }
  1343.     t_ptr->cost = 0;
  1344.     t_ptr->ac = -m_bonus(2, 45, level);
  1345.       }
  1346.       break;
  1347.  
  1348.     case 33:  /* Helms */
  1349.       if (magik(chance))
  1350.     {
  1351.       t_ptr->toac = m_bonus(1, 20, level);
  1352.       if (magik(special))
  1353.         switch(t_ptr->subval)
  1354.           {
  1355.           case 1: case 2: case 3: case 4: case 5:
  1356.         switch(randint(3))
  1357.           {
  1358.           case 1:
  1359.             t_ptr->p1 = randint(2);
  1360.             t_ptr->flags |= 0x00000008;
  1361.             (void) strcat(t_ptr->name, " of Intelligence (%P1)");
  1362.             t_ptr->cost += t_ptr->p1*500;
  1363.             break;
  1364.           case 2:
  1365.             t_ptr->p1 = randint(2);
  1366.             t_ptr->flags |= 0x00000010;
  1367.               (void) strcat(t_ptr->name, " of Wisdom (%P1)");
  1368.             t_ptr->cost += t_ptr->p1*500;
  1369.             break;
  1370.           case 3:
  1371.             t_ptr->p1 = 1 + randint(4);
  1372.             t_ptr->flags |= 0x40000000;
  1373.             (void) strcat(t_ptr->name, " of Infra-Vision (%P1)");
  1374.             t_ptr->cost += t_ptr->p1*250;
  1375.             break;
  1376.           }
  1377.         break;
  1378.           case 6: case 7: case 8:
  1379.         switch(randint(6))
  1380.           {
  1381.           case 1:
  1382.             t_ptr->p1 = randint(3);
  1383.             t_ptr->flags |= 0x00800007;
  1384.             (void) strcat(t_ptr->name, " of Might (%P1)");
  1385.             t_ptr->cost += 1000 + t_ptr->p1*500;
  1386.             break;
  1387.           case 2:
  1388.             t_ptr->p1 = randint(3);
  1389.             t_ptr->flags |= 0x00000030;
  1390.             (void) strcat(t_ptr->name, " of Lordliness (%P1)");
  1391.             t_ptr->cost += 1000 + t_ptr->p1*500;
  1392.             break;
  1393.           case 3:
  1394.             t_ptr->p1 = randint(3);
  1395.             t_ptr->flags |= 0x01380008;
  1396.             (void) strcat(t_ptr->name, " of the Magi (%P1)");
  1397.             t_ptr->cost += 3000 + t_ptr->p1*500;
  1398.             break;
  1399.           case 4:
  1400.             t_ptr->p1 = randint(3);
  1401.             t_ptr->flags |= 0x00000020;
  1402.             (void) strcat(t_ptr->name, " of Beauty (%P1)");
  1403.             t_ptr->cost += 750;
  1404.             break;
  1405.           case 5:
  1406.             t_ptr->p1 = 1 + randint(4);
  1407.             t_ptr->flags |= 0x01000040;
  1408.             (void) strcat(t_ptr->name, " of Seeing (%P1)");
  1409.             t_ptr->cost += 1000 + t_ptr->p1*100;
  1410.             break;
  1411.           case 6:
  1412.             t_ptr->flags |= 0x00000800;
  1413.             (void) strcat(t_ptr->name, " of Regeneration");
  1414.             t_ptr->cost += 1500;
  1415.             break;
  1416.           }
  1417.         break;
  1418.           }
  1419.       else if (magik(cursed))
  1420.         {
  1421.           t_ptr->toac = -m_bonus(1, 45, level);
  1422.           t_ptr->flags |= 0x80000000;
  1423.           t_ptr->cost = 0;
  1424.           if (magik(special))
  1425.           switch(randint(7))
  1426.         {
  1427.         case 1:
  1428.           t_ptr->p1 = -1;
  1429.           t_ptr->flags |= 0x00000008;
  1430.           (void) strcat(t_ptr->name, " of Stupidity");
  1431.           break;
  1432.         case 2:
  1433.           t_ptr->p1 = -1;
  1434.           t_ptr->flags |= 0x00000010;
  1435.           (void) strcat(t_ptr->name, " of Dullness");
  1436.           break;
  1437.         case 3:
  1438.           t_ptr->flags |= 0x08000000;
  1439.           (void) strcat(t_ptr->name, " of Blindness");
  1440.           break;
  1441.         case 4:
  1442.           t_ptr->flags |= 0x10000000;
  1443.           (void) strcat(t_ptr->name, " of Timidness");
  1444.           break;
  1445.         case 5:
  1446.           t_ptr->p1 = -1;
  1447.           t_ptr->flags |= 0x00000001;
  1448.           (void) strcat(t_ptr->name, " of Weakness");
  1449.           break;
  1450.         case 6:
  1451.           t_ptr->flags |= 0x00000400;
  1452.           (void) strcat(t_ptr->name, " of Teleportation");
  1453.           break;
  1454.         case 7:
  1455.           t_ptr->p1 = -1;
  1456.           t_ptr->flags |= 0x00000020;
  1457.           (void) strcat(t_ptr->name, " of Ugliness");
  1458.           break;
  1459.         }
  1460.           t_ptr->p1 = t_ptr->p1 * randint (5);
  1461.         }
  1462.     }
  1463.       break;
  1464.  
  1465.     case 45: /* Rings         */
  1466.       switch(t_ptr->subval)
  1467.     {
  1468.     case 1: case 2: case 3: case 4: case 5: case 6:
  1469.       if (magik(cursed))
  1470.         {
  1471.           t_ptr->p1 = -m_bonus(1, 20, level);
  1472.           t_ptr->flags |= 0x80000000;
  1473.           t_ptr->cost = -t_ptr->cost;
  1474.         }
  1475.       else
  1476.         {
  1477.           t_ptr->p1 = m_bonus(1, 10, level);
  1478.           t_ptr->cost += t_ptr->p1*100;
  1479.         }
  1480.       break;
  1481.     case 7:
  1482.       if (magik(cursed))
  1483.         {
  1484.           t_ptr->p1 = -randint(3);
  1485.           t_ptr->flags |= 0x80000000;
  1486.           t_ptr->cost = -t_ptr->cost;
  1487.         }
  1488.       else
  1489.         t_ptr->p1 = 1;
  1490.       break;
  1491.     case 8:
  1492.       t_ptr->p1 = 5*m_bonus(1, 20, level);
  1493.       t_ptr->cost += t_ptr->p1*100;
  1494.       break;
  1495.     case 22:     /* Increase damage       */
  1496.       t_ptr->todam = m_bonus(1, 20, level);
  1497.       t_ptr->cost += t_ptr->todam*100;
  1498.       if (magik(cursed))
  1499.         {
  1500.           t_ptr->todam = -t_ptr->todam;
  1501.           t_ptr->flags |= 0x80000000;
  1502.           t_ptr->cost = -t_ptr->cost;
  1503.         }
  1504.       break;
  1505.     case 23:     /* Increase To-Hit       */
  1506.       t_ptr->tohit = m_bonus(1, 20, level);
  1507.       t_ptr->cost += t_ptr->tohit*100;
  1508.       if (magik(cursed))
  1509.         {
  1510.           t_ptr->tohit = -t_ptr->tohit;
  1511.           t_ptr->flags |= 0x80000000;
  1512.           t_ptr->cost = -t_ptr->cost;
  1513.         }
  1514.       break;
  1515.     case 24:     /* Protection            */
  1516.       t_ptr->toac = m_bonus(1, 20, level);
  1517.       t_ptr->cost += t_ptr->toac*100;
  1518.       if (magik(cursed))
  1519.         {
  1520.           t_ptr->toac = -t_ptr->toac;
  1521.           t_ptr->flags |= 0x80000000;
  1522.           t_ptr->cost = -t_ptr->cost;
  1523.         }
  1524.       break;
  1525.     case 33:     /* Slaying       */
  1526.       t_ptr->todam = m_bonus(1, 25, level);
  1527.       t_ptr->tohit = m_bonus(1, 25, level);
  1528.       t_ptr->cost += (t_ptr->tohit+t_ptr->todam)*100;
  1529.       if (magik(cursed))
  1530.         {
  1531.           t_ptr->tohit = -t_ptr->tohit;
  1532.           t_ptr->todam = -t_ptr->todam;
  1533.           t_ptr->flags |= 0x80000000;
  1534.           t_ptr->cost = -t_ptr->cost;
  1535.         }
  1536.       break;
  1537.     default:
  1538.       break;
  1539.     }
  1540.       break;
  1541.  
  1542.     case 40: /* Amulets       */
  1543.       switch(t_ptr->subval)
  1544.     {
  1545.     case 1: case 2: case 3: case 4: case 5: case 6:
  1546.       if (magik(cursed))
  1547.         {
  1548.           t_ptr->p1 = -m_bonus(1, 20, level);
  1549.           t_ptr->flags |= 0x80000000;
  1550.           t_ptr->cost = -t_ptr->cost;
  1551.         }
  1552.       else
  1553.         {
  1554.           t_ptr->p1 = m_bonus(1, 10, level);
  1555.           t_ptr->cost += t_ptr->p1*100;
  1556.         }
  1557.       break;
  1558.     case 7:
  1559.       t_ptr->p1 = 5*m_bonus(1, 25, level);
  1560.       if (magik(cursed))
  1561.         {
  1562.           t_ptr->p1 = -t_ptr->p1;
  1563.           t_ptr->cost = -t_ptr->cost;
  1564.           t_ptr->flags |= 0x80000000;
  1565.         }
  1566.       else
  1567.         t_ptr->cost += 20*t_ptr->p1;
  1568.       break;
  1569.     default:
  1570.       break;
  1571.     }
  1572.       break;
  1573.  
  1574.       /* Subval should be even for store, odd for dungeon*/
  1575.       /* Dungeon found ones will be partially charged    */
  1576.     case 15: /* Lamps and torches*/
  1577.       if ((t_ptr->subval % 2) == 1)
  1578.     t_ptr->p1 = randint(t_ptr->p1);
  1579.       break;
  1580.  
  1581.     case 65: /* Wands         */
  1582.       switch(t_ptr->subval)
  1583.     {
  1584.     case 1:   t_ptr->p1 = randint(10) +      6; break;
  1585.     case 2:   t_ptr->p1 = randint(8)  +      6; break;
  1586.     case 3:   t_ptr->p1 = randint(5)  +      6; break;
  1587.     case 4:   t_ptr->p1 = randint(8)  +      6; break;
  1588.     case 5:   t_ptr->p1 = randint(4)  +      3; break;
  1589.     case 6:   t_ptr->p1 = randint(8)  +      6; break;
  1590.     case 7:   t_ptr->p1 = randint(20) +      12; break;
  1591.     case 8:   t_ptr->p1 = randint(20) +      12; break;
  1592.     case 9:   t_ptr->p1 = randint(10) +      6; break;
  1593.     case 10:   t_ptr->p1 = randint(12) +      6; break;
  1594.     case 11:   t_ptr->p1 = randint(10) +      12; break;
  1595.     case 12:   t_ptr->p1 = randint(3)  +      3; break;
  1596.     case 13:   t_ptr->p1 = randint(8)  +      6; break;
  1597.     case 14:   t_ptr->p1 = randint(10) +      6; break;
  1598.     case 15:   t_ptr->p1 = randint(5)  +      3; break;
  1599.     case 16:   t_ptr->p1 = randint(5)  +      3; break;
  1600.     case 17:   t_ptr->p1 = randint(5)  +      6; break;
  1601.     case 18:   t_ptr->p1 = randint(5)  +      4; break;
  1602.     case 19:   t_ptr->p1 = randint(8)  +      4; break;
  1603.     case 20:   t_ptr->p1 = randint(6)  +      2; break;
  1604.     case 21:   t_ptr->p1 = randint(4)  +      2; break;
  1605.     case 22:   t_ptr->p1 = randint(8)  +      6; break;
  1606.     case 23:   t_ptr->p1 = randint(5)  +      2; break;
  1607.     case 24:   t_ptr->p1 = randint(12) + 12; break;
  1608.     default:
  1609.       break;
  1610.     }
  1611.       break;
  1612.  
  1613.     case 55: /* Staffs        */
  1614.       switch(t_ptr->subval)
  1615.     {
  1616.     case 1:   t_ptr->p1 = randint(20) +      12; break;
  1617.     case 2:   t_ptr->p1 = randint(8)  +      6; break;
  1618.     case 3:   t_ptr->p1 = randint(5)  +      6; break;
  1619.     case 4:   t_ptr->p1 = randint(20) +      12; break;
  1620.     case 5:   t_ptr->p1 = randint(15) +      6; break;
  1621.     case 6:   t_ptr->p1 = randint(4)  +      5; break;
  1622.     case 7:   t_ptr->p1 = randint(5)  +      3; break;
  1623.     case 8:   t_ptr->p1 = randint(3)  +      1; break;
  1624.     case 9:   t_ptr->p1 = randint(3)  +      1; break;
  1625.     case 10:   t_ptr->p1 = randint(3)  +      1; break;
  1626.     case 11:   t_ptr->p1 = randint(5)  +      6; break;
  1627.     case 12:   t_ptr->p1 = randint(10) +      12; break;
  1628.     case 13:   t_ptr->p1 = randint(5)  +      6; break;
  1629.     case 14:   t_ptr->p1 = randint(5)  +      6; break;
  1630.     case 15:   t_ptr->p1 = randint(5)  +      6; break;
  1631.     case 16:   t_ptr->p1 = randint(10) +      12; break;
  1632.     case 17:   t_ptr->p1 = randint(3)  +      4; break;
  1633.     case 18:   t_ptr->p1 = randint(5)  +      6; break;
  1634.     case 19:   t_ptr->p1 = randint(5)  +      6; break;
  1635.     case 20:   t_ptr->p1 = randint(3)  +      4; break;
  1636.     case 21:   t_ptr->p1 = randint(10) +      12; break;
  1637.     case 22:   t_ptr->p1 = randint(3)  +      4; break;
  1638.     case 23:   t_ptr->p1 = randint(3)  +      4; break;
  1639.     case 24:   t_ptr->p1 = randint(3)  +      1; break;
  1640.     case 25:   t_ptr->p1 = randint(10) + 6; break;
  1641.     default:
  1642.       break;
  1643.     }
  1644.       break;
  1645.  
  1646.     case 32: /* Cloaks        */
  1647.       if (magik(chance))
  1648.     {
  1649.       if (magik(special))
  1650.         switch(randint(2))
  1651.           {
  1652.           case 1:
  1653.         (void) strcat(t_ptr->name, " of Protection");
  1654.         t_ptr->toac = m_bonus(2, 40, level);
  1655.         t_ptr->cost += 250;
  1656.         break;
  1657.           case 2:
  1658.         t_ptr->toac = m_bonus(1, 20, level);
  1659.         t_ptr->p1 = randint(3);
  1660.         t_ptr->flags |= 0x00000100;
  1661.         (void) strcat(t_ptr->name, " of Stealth (%P1)");
  1662.         t_ptr->cost += 500;
  1663.         break;
  1664.           }
  1665.       else
  1666.         t_ptr->toac = m_bonus(1, 20, level);
  1667.     }
  1668.       else if (magik(cursed))
  1669.     switch(randint(3))
  1670.       {
  1671.       case 1:
  1672.         t_ptr->flags |= 0x80000200;
  1673.         (void) strcat(t_ptr->name, " of Irritation");
  1674.         t_ptr->ac   =  0;
  1675.         t_ptr->toac  = -m_bonus(1, 10, level);
  1676.         t_ptr->tohit = -m_bonus(1, 10, level);
  1677.         t_ptr->todam = -m_bonus(1, 10, level);
  1678.         t_ptr->cost =  0;
  1679.         break;
  1680.       case 2:
  1681.         t_ptr->flags |= 0x80000000;
  1682.         (void) strcat(t_ptr->name, " of Vulnerability");
  1683.         t_ptr->ac   = 0;
  1684.         t_ptr->toac = -m_bonus(10, 100, level+50);
  1685.         t_ptr->cost = 0;
  1686.         break;
  1687.       case 3:
  1688.         t_ptr->flags |= 0x80000000;
  1689.         (void) strcat(t_ptr->name, " of Enveloping");
  1690.         t_ptr->toac  = -m_bonus(1, 10, level);
  1691.         t_ptr->tohit = -m_bonus(2, 40, level+10);
  1692.         t_ptr->todam = -m_bonus(2, 40, level+10);
  1693.         t_ptr->cost = 0;
  1694.         break;
  1695.       }
  1696.       break;
  1697.  
  1698.     case 2: /* Chests        */
  1699.       switch(randint(level+4))
  1700.     {
  1701.     case 1:
  1702.       t_ptr->flags = 0;
  1703.       (void) strcat(t_ptr->name, "^ (Empty)");
  1704.       break;
  1705.     case 2:
  1706.       t_ptr->flags |= 0x00000001;
  1707.       (void) strcat(t_ptr->name, "^ (Locked)");
  1708.       break;
  1709.     case 3: case 4:
  1710.       t_ptr->flags |= 0x00000011;
  1711.       (void) strcat(t_ptr->name, "^ (Poison Needle)");
  1712.       break;
  1713.     case 5: case 6:
  1714.       t_ptr->flags |= 0x00000021;
  1715.       (void) strcat(t_ptr->name, "^ (Poison Needle)");
  1716.       break;
  1717.     case 7: case 8: case 9:
  1718.       t_ptr->flags |= 0x00000041;
  1719.       (void) strcat(t_ptr->name, "^ (Gas Trap)");
  1720.       break;
  1721.     case 10: case 11:
  1722.       t_ptr->flags |= 0x00000081;
  1723.       (void) strcat(t_ptr->name, "^ (Explosion Device)");
  1724.       break;
  1725.     case 12: case 13: case 14:
  1726.       t_ptr->flags |= 0x00000101;
  1727.       (void) strcat(t_ptr->name, "^ (Summoning Runes)");
  1728.       break;
  1729.     case 15: case 16: case 17:
  1730.       t_ptr->flags |= 0x00000071;
  1731.       (void) strcat(t_ptr->name, "^ (Multiple Traps)");
  1732.       break;
  1733.     default:
  1734.       t_ptr->flags |= 0x00000181;
  1735.       (void) strcat(t_ptr->name, "^ (Multiple Traps)");
  1736.       break;
  1737.     }
  1738.       break;
  1739.  
  1740.     case 10: case 11: case 12: case 13:  /* Arrows, bolts, ammo, and spikes */
  1741.       if ((t_ptr->tval == 11) || (t_ptr->tval == 12))
  1742.     if (magik(chance))
  1743.       {
  1744.         t_ptr->tohit = m_bonus(1, 35, level);
  1745.         t_ptr->todam = m_bonus(1, 35, level);
  1746.         if (magik(special))
  1747.           switch(t_ptr->tval)  /*SWITCH 1*/
  1748.         {
  1749.         case 11: case 12:
  1750.           switch(randint(10))   /*SWITCH 2*/
  1751.             {
  1752.             case 1: case 2: case 3:
  1753.               (void) strcat(t_ptr->name, " of Slaying");
  1754.               t_ptr->tohit += 5;
  1755.               t_ptr->todam += 5;
  1756.               t_ptr->cost += 20;
  1757.               break;
  1758.             case 4: case 5:
  1759.               t_ptr->flags |= 0x00040000;
  1760.               t_ptr->tohit += 2;
  1761.               t_ptr->todam += 4;
  1762.               (void) strcat(t_ptr->name, " of Fire");
  1763.               t_ptr->cost += 25;
  1764.               break;
  1765.             case 6: case 7:
  1766.               t_ptr->flags |= 0x00008000;
  1767.               t_ptr->tohit += 3;
  1768.               t_ptr->todam += 3;
  1769.               (void) strcat(t_ptr->name, " of Slay Evil");
  1770.               t_ptr->cost += 25;
  1771.               break;
  1772.             case 8: case 9:
  1773.               t_ptr->flags |= 0x01004000;
  1774.               t_ptr->tohit += 2;
  1775.               t_ptr->todam += 2;
  1776.               (void) strcat(t_ptr->name, " of Slay Monster");
  1777.               t_ptr->cost += 30;
  1778.               break;
  1779.             case 10:
  1780.               t_ptr->flags |= 0x00002000;
  1781.               t_ptr->tohit += 10;
  1782.               t_ptr->todam += 10;
  1783.               (void) strcat(t_ptr->name, " of Dragon Slaying");
  1784.               t_ptr->cost += 35;
  1785.               break;
  1786.             } /*SWITCH 2*/
  1787.         default:
  1788.           break;
  1789.         }  /*SWITCH 1*/
  1790.       }
  1791.     else if (magik(cursed))
  1792.       {
  1793.         t_ptr->tohit = -m_bonus(5, 55, level);
  1794.         t_ptr->todam = -m_bonus(5, 55, level);
  1795.         t_ptr->flags |= 0x80000000;
  1796.         t_ptr->cost = 0;
  1797.       }
  1798.  
  1799.       t_ptr->number = 0;
  1800.       for (i = 0; i < 7; i++)
  1801.     t_ptr->number += randint(6);
  1802.       missile_ctr++;
  1803.       if (missile_ctr > 65000)
  1804.     missile_ctr = 1;
  1805.       t_ptr->subval = missile_ctr + 512;
  1806.       break;
  1807.  
  1808.     default:
  1809.       break;
  1810.     }
  1811. }
  1812.  
  1813.  
  1814.